[RyuJIT Wasm] Add Object Writer Imports Section + Constant Exprs to Encode R2R Payload Placement #123739

adamperlin · 2026-01-28T23:52:53Z

This PR adds support for generating an import section to the WasmObjectWriter. We currently import:

__stack_pointer
__r2r_start

Various data segments are then placed into __r2r_start + <segment_offset>. We use the constant expressions extension for these address calculations.

…k pointer, and r2r start address by default

Lay out R2R data segments relative to imported __r2r_start global

kg · 2026-01-28T23:58:44Z

I will try and update the test harness to be compatible with this

dotnet-policy-service · 2026-01-29T17:21:31Z

Tagging subscribers to 'arch-wasm': @lewing, @pavelsavara
See info in area-owners.md if you want to be subscribed.

…o WasmImport

adamperlin · 2026-01-29T23:43:22Z

@kg I'd love a review on this when you have a chance!

Copilot

Pull request overview

Adds initial support for emitting a Wasm import section from WasmObjectWriter, and switches R2R data segment placement to use constant expressions based on an imported __r2r_start symbol.

Changes:

Introduces a new wasm.import object node section and emits it as Wasm section type Import.
Reworks combined data segment placement to use an instruction expression (global.get __r2r_start + i32.const offset + i32.add) instead of a fixed DataStartOffset.
Adds a small Wasm encoding model (imports, globals, memory type, expression/instruction encoding) and a helper to write UTF-8 strings with a length prefix.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 7 comments.

File	Description
src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs	Adds import section emission and uses `__r2r_start + offset` constant expressions for data segment placement.
src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs	Adds encodable abstractions/types for Wasm expressions and import encodings (memory/global types, etc.).
src/coreclr/tools/Common/Compiler/ObjectWriter/SectionWriter.cs	Adds `WriteUtf8WithLength` helper for Wasm-style length-prefixed strings.

Copilot · 2026-01-29T23:48:55Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs

+    class WasmInstructionGroup : IWasmEncodable
+    {
+        readonly WasmExpr[] WasmExprs;
+        public WasmInstructionGroup(WasmExpr[] wasmExprs)
+        {
+            WasmExprs = wasmExprs;
+        }


WasmInstructionGroup uses a field named WasmExprs without the underscore prefix used elsewhere in this file (e.g., _types, _params, _returns). Rename to _wasmExprs (and update usages) to match the established local naming convention and improve readability.

Copilot · 2026-01-29T23:48:55Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs

+        public WasmMemoryType(WasmLimitType limitType, uint min, uint? max = null)
+        {
+            if (LimitType == WasmLimitType.HasMinAndMax && !Max.HasValue)
+            {
+                throw new ArgumentException("Max must be provided when LimitType is HasMinAndMax");
+            }
+
+            LimitType = limitType;
+            Min = min;
+            Max = max;
+        }
+
+        public override int Encode(Span<byte> buffer)
+        {
+            int pos = 0;
+            buffer[pos++] = (byte)LimitType;
+            pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), Min);
+            if (LimitType == WasmLimitType.HasMinAndMax)
+            {
+                pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), Max!.Value);
+            }
+            return pos;
+        }
+
+        public override int EncodeSize() => 2;
+    }


WasmMemoryType has two issues:

The constructor validates LimitType/Max fields before they’re assigned, so the check never does what it intends. It should validate the limitType/max parameters.

EncodeSize() returns a constant 2, but Encode(...) writes a variable-length payload (1 byte + ULEB128(min) [+ ULEB128(max)]). This will cause callers using EncodeSize() (e.g., import encoding) to allocate the wrong buffer size and can lead to truncated writes/corruption. Compute the size using DwarfHelper.SizeOfULEB128 for min/max and include the leading limit-type byte.

Copilot · 2026-01-29T23:48:55Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

+            int size = import.EncodeSize();
+            import.Encode(writer.Buffer.GetSpan(size));
+            writer.Buffer.Advance((int)size);


WriteImport advances the section buffer by EncodeSize() rather than by the actual byte count returned from Encode(...). If EncodeSize() and Encode() ever diverge (or a future implementation writes fewer bytes), this will either leave garbage bytes in the section or corrupt subsequent writes. Capture the return value from Encode(...), assert it matches the expected size, and advance by the encoded byte count.

Suggested change

int size = import.EncodeSize();

import.Encode(writer.Buffer.GetSpan(size));

writer.Buffer.Advance((int)size);

int expectedSize = import.EncodeSize();

Span<byte> buffer = writer.Buffer.GetSpan(expectedSize);

int encodedSize = import.Encode(buffer);

Debug.Assert(encodedSize == expectedSize, $"Encoded import size mismatch in {nameof(WriteImport)}.");

writer.Buffer.Advance(encodedSize);

Copilot · 2026-01-29T23:48:56Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

+            WasmInstructionGroup GetR2StartOffset(int offset)
+            {
+                return new WasmInstructionGroup([
+                    Global.Get(1), // __r2r_start
+                    I32.Const(offset),
+                    I32.Add,
+                ]);


GetR2StartOffset hard-codes Global.Get(1) for __r2r_start. This couples data segment placement to the current import/global ordering and will silently break if another imported/defined global is added earlier. Consider tracking the global index for __r2r_start when writing imports (e.g., via constants/enums or by computing the index from the import list) and use that value here.

Copilot · 2026-01-29T23:48:56Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

+            ulong numPages = (contentSize + (1<<16) - 1) >> 16;
+
+            _defaultImports[0] = new WasmImport("env", "memory", WasmExternalKind.Memory,
+                new WasmMemoryType(0x00, (uint)numPages)); // memory limits: flags (0 = only minimum)


new WasmMemoryType(0x00, (uint)numPages) passes an integer literal where WasmMemoryType expects a WasmLimitType, which will not compile. Use WasmLimitType.HasMin (or an explicit cast) for the first argument.

Suggested change

new WasmMemoryType(0x00, (uint)numPages)); // memory limits: flags (0 = only minimum)

new WasmMemoryType(WasmLimitType.HasMin, (uint)numPages)); // memory limits: flags (HasMin = only minimum)

Copilot · 2026-01-29T23:48:56Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

+            // Calculate the required memory size based on the combined data section size
+            ulong contentSize = (ulong)SectionByName(WasmObjectNodeSection.CombinedDataSection.Name).ContentSize;
+            ulong numPages = (contentSize + (1<<16) - 1) >> 16;
+


numPages is computed only from the combined data section’s encoded size. This can (a) produce a 0-page minimum when there are no data segments, and (b) ignores any non-zero base placement such as the previous DataStartOffset (and now potentially __r2r_start). Since the import’s minimum is the module’s only enforcement on the host-provided memory size, consider clamping to at least 1 page and/or adding a fixed base reservation (stack / __r2r_start placement) so the requested minimum can’t be smaller than the runtime’s expected address range.

Copilot

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

kg · 2026-01-30T07:59:40Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs

    }
+
+    // Simple DSL wrapper for creating Wasm expressions
+    static class Global


Please put the DSL in a namespace of its own

kg · 2026-01-30T08:05:12Z

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

-        private WasmDataSection CreateCombinedDataSection(int dataStartOffset)
+        private WasmDataSection CreateCombinedDataSection()
        {
+            WasmInstructionGroup GetR2StartOffset(int offset)


Should it be GetR2RStartOffset

kg · 2026-01-30T08:06:51Z

This looks fairly good, all of Copilot's feedback seemed accurate though so we need to address it.
The Encode/EncodeSize split is a little awkward but I don't see an obvious way to get rid of it other than doing something weird with empty spans.

adamperlin added 2 commits January 27, 2026 17:00

Add basic import section to WasmObject writer, importing memory, stac…

bd0cac5

…k pointer, and r2r start address by default

Add addtional expression types for wasm instructions

da9edbb

Lay out R2R data segments relative to imported __r2r_start global

adamperlin requested a review from kg January 28, 2026 23:53

github-actions bot added the needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners label Jan 28, 2026

dotnet-policy-service bot assigned adamperlin Jan 28, 2026

am11 added arch-wasm WebAssembly architecture area-crossgen2-coreclr and removed needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners labels Jan 29, 2026

Slight refactoring: Add WasmExpr dsl and move some encoding logic int…

6232eef

…o WasmImport

Copilot AI review requested due to automatic review settings January 29, 2026 23:38

Copilot started reviewing on behalf of adamperlin January 29, 2026 23:39 View session

adamperlin marked this pull request as ready for review January 29, 2026 23:42

adamperlin requested a review from MichalStrehovsky as a code owner January 29, 2026 23:42

Copilot AI reviewed Jan 29, 2026

View reviewed changes

This was referenced Jan 30, 2026

iOS.Device test WorkItemExecutions #122874

Open

[Wasm] The request was canceled due to the configured HttpClient.Timeout of 100 seconds elapsing #123572

Open

kg reviewed Jan 30, 2026

View reviewed changes

-            int size = import.EncodeSize();
-            import.Encode(writer.Buffer.GetSpan(size));
-            writer.Buffer.Advance((int)size);
+            int expectedSize = import.EncodeSize();
+            Span<byte> buffer = writer.Buffer.GetSpan(expectedSize);
+            int encodedSize = import.Encode(buffer);
+            Debug.Assert(encodedSize == expectedSize, $"Encoded import size mismatch in {nameof(WriteImport)}.");
+            writer.Buffer.Advance(encodedSize);

	new WasmMemoryType(0x00, (uint)numPages)); // memory limits: flags (0 = only minimum)
	new WasmMemoryType(WasmLimitType.HasMin, (uint)numPages)); // memory limits: flags (HasMin = only minimum)

[RyuJIT Wasm] Add Object Writer Imports Section + Constant Exprs to Encode R2R Payload Placement #123739

Are you sure you want to change the base?

[RyuJIT Wasm] Add Object Writer Imports Section + Constant Exprs to Encode R2R Payload Placement #123739

Conversation

adamperlin commented Jan 28, 2026

Uh oh!

kg commented Jan 28, 2026

Uh oh!

dotnet-policy-service bot commented Jan 29, 2026

Uh oh!

adamperlin commented Jan 29, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Uh oh!

kg Jan 30, 2026

Choose a reason for hiding this comment

Uh oh!

kg Jan 30, 2026

Choose a reason for hiding this comment

Uh oh!

kg commented Jan 30, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants